home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / programm / MM2_DEV / S / GME / GMECONFI.I < prev    next >
Encoding:
Text File  |  1994-02-17  |  48.6 KB  |  1,338 lines
  1.  
  2. (*      GMEConfig
  3.         ---------
  4.  
  5.   Stand: 21.05.91                           (c) 1990 by Johannes Leckebusch
  6.  
  7.   Dieses Modul enthält die Konfiguration der Benutzerschnittstelle.
  8.   Sein Quelltext steht erfahrenen Programmierern zur Verfügung, damit
  9.   sie sich die Bedienung des Editors - insbesondere die Tastaturbelegung -
  10.   nach eigenen Wünschen anpassen können. Eine Anleitung hierzu finden Sie in
  11.   Abschnitt 5.1 und 5.2 des GME-Handbuchs.
  12.  
  13.   ACHTUNG: Die beiden im folgenden auskommentierten Definitionen
  14.   von GMEBase und GMEConfig sind vorher zu übersetzen, um die benötigten
  15.   DEF-Files zu erhalten!
  16.  
  17. -------------------------------------------------------------------------------
  18. 18.12.90    Veröffentlichung mit MM2 Version 2.2
  19. 19.02.91    Die KbdEvents werden ggf. wieder deinstalliert.
  20. 09.03.91    GME Version 1.1: "LiesTaste" liefert RightMous/Leftmous wiederholt
  21.             solange, wie die Taste niedergedrückt bleibt.
  22. 21.05.91    Definitionstexte aktualisiert, so daß kein Versionskonflikt mehr
  23.             bei Neuübersetzung auftritt.
  24. -------------------------------------------------------------------------------
  25. *)
  26.  
  27. (*
  28. DEFINITION MODULE GMEBase;
  29. (*$Z+*)
  30.  
  31. FROM SYSTEM IMPORT TSIZE;
  32. FROM GEMEnv IMPORT DeviceHandle, GemHandle;
  33.  
  34. (* Von EditConst *)
  35.  
  36. CONST
  37.         maxItem =               24; (* Magic Number in MENU.MOD *)
  38.         maxItemLen =            78;
  39.         maxLev =                1; (* MENU.Grenzen *)
  40.         
  41.         cRevision =             000011L;
  42.         cAllocate =             16;
  43.  
  44. (* Definition wichtiger ASCII-Codes (NICHT Tastencodes! *)
  45.  
  46.         eot =           32C; (* ??? *)
  47.  
  48.         cZeile =                1023;
  49.         cInfo =                 128;
  50.  
  51.         cTextUmbruch =          65;
  52.         cUeberschriftLaenge =   68;
  53.         cTabWeite =             8;
  54.         cKopfVorlauf =          0;
  55.         cKopfNachlauf =         2;
  56.         cZeilenAbstand =        2; (* 1/72 Zoll! Zahl unsinnig. *)
  57.         cSpiegel =              60;
  58.         cOffset =               0;
  59.         cSchreibZaehler =       1500;
  60.  
  61. (* Von EditType *)
  62.  
  63. TYPE    einStringPointer =      POINTER TO eineZeile;
  64.         eineZeile =             ARRAY [0..cZeile] OF CHAR;
  65.         eineInfo =              ARRAY [0..cInfo] OF CHAR;
  66.         CharSet =               SET OF CHAR;
  67.  
  68.         einLinePointer =        POINTER TO aLine;
  69.  
  70.         aLine =                 RECORD
  71.                                   vorige, naechste: einLinePointer;   (* 8 *)
  72.                                   ZeilPointer:      einStringPointer; (* 4 *)
  73.                                   laenge:           CARDINAL;         (* 2 *)
  74.                                   terminator:   ARRAY [0..1] OF CHAR; (* 2 *)
  75.                                 END (* aLine *);    (* TSIZE =          16 *)
  76.  
  77.         einMerkPointer =        POINTER TO einMerkPunkt;
  78.  
  79.         einMerkPunkt =          RECORD
  80.                                   zeilpos:      CARDINAL;             (* 2 *)
  81.                                   charpos:      CARDINAL;             (* 2 *)
  82.                                   merkline:     einLinePointer;       (* 4 *)
  83.                                   merkinfo:     einLinePointer;       (* 4 *)
  84.                                   nextMerk:     einMerkPointer;       (* 4 *)
  85.                                 END (* einMerkPunkt *); (* TSIZE =      16 *)
  86.  
  87.         MerkIndex =             (ErsteZeile, LaufendeZeile,
  88.                                  MerkPunkt1, MerkPunkt2, CompilerInfo,
  89.                                  BlockMarke1, BlockMarke2, PufferVergleich,
  90.                                  IndexListe, DruckerSteuer,
  91.                                  Protokoll, Textbausteine, Datei, M13, M14,
  92.                                  LetztePosition);
  93.  
  94.         einMerkSet =            SET OF MerkIndex;
  95.  
  96.         Mode =                  ((*TextModus*) Compiliert, ControlZeichen,
  97.                                  (* ControlZFiltern - fehlt leider *)
  98.                                  OverWrite, AutoIndent, Editiert,
  99.                                  WortSuche, GrossKleinSuche,
  100.                                  BlockIstMarkiert,
  101.                                  Changed,
  102.                                  IndexScan, (* Indexgenerierung - not used*)
  103.                                  Exit, (* 10 *)
  104.  
  105.                                  (* File-Flags: *)
  106.                                  KonfigSpeichern, AutoSave, TabFiltern,
  107.                                  DruckerfilterLaden, FontLaden, (* 15 *)
  108.  
  109.                                  (* *)
  110.                                  Flag16, Flag17,
  111.                                  Flag18, Flag19, (* 19 *)
  112.                                  Flag20, Flag21,
  113.                                  Flag22, Flag23, (* 23 *)
  114.                                  Flag24, Flag25,
  115.                                  Flag26, Flag27, (* 27 *)
  116.                                  Flag28,
  117.                                  MakeBAK (* .BAK, .OLD *),
  118.                                  Flag30, (* 30 *)
  119.                                  Expand0); (* 31 = 32 Bit *)
  120.  
  121.         Moden =                 SET OF Mode;
  122.  
  123.         einPufferPointer = POINTER TO einPufferDeskriptor;
  124.  
  125.         einPufferDeskriptor =
  126.                         RECORD
  127.                           MagicRevision:                LONGCARD;
  128.                           Puffer:                       einLinePointer;
  129.                                                                    (* 4 *)
  130.                           ZeilenAnzahl:                 CARDINAL;  (* 2 *)
  131.                           MerkPunkte:                   ARRAY MerkIndex OF
  132.                                                           einMerkPunkt;
  133.                                                         (* 16 * 16 =  256 *)
  134.                           Modus:                        Moden;    (*  4 *)
  135.                           Pfad, Name:                   eineInfo;(* 120 *)
  136.                           Max:                          CARDINAL;  (* 2 *)
  137.                           TabWeite:                     CARDINAL;  (* 2 *)
  138.                           NaechsterPuffer:              einPufferPointer;
  139.                           
  140.                           SchreibZaehler:               CARDINAL;  (* 2 *)
  141.                             (* Fuer Autosave *)
  142.                           tageszeit:                    CARDINAL;  (* 2 *)
  143.                           datum:                        CARDINAL;  (* 2 *)
  144.                         END (* einPufferDeskriptor *); (* TSIZE =    *)
  145.  
  146. VAR     PuffRecSize: (*TSIZE (einPufferDeskriptor)*) LONGCARD;
  147.  
  148. (* Von ScreenBase *)
  149.  
  150. CONST   (* Definition wichtiger ASCII-Codes (NICHT Tastencodes! *)
  151.         nul =           0C;     (* ASCII-Nul, kein Zeichen *)
  152.  
  153.         bel =           07C;
  154.         backspace =     10C;    (* rueckwaerts loeschen *)
  155.         tab =           11C;    (* in 8er-Positionen einruecken *)
  156.  
  157.         (* Bildschirmattribute: *)
  158.  
  159.         hasinsert =     FALSE;
  160.         hasdelete =     FALSE;
  161.  
  162.         escape =        33C;
  163.         lf =            12C;
  164.         cr =            15C;
  165.  
  166.         linedel =      115C;
  167.         lineins =      114C;
  168.         
  169.         Ja =            1;
  170.         Nein =          2;
  171.         Abbruch =       3;
  172.  
  173. TYPE    einButton =        (Left, Right);
  174.         ButtonSet =        SET OF einButton;
  175.  
  176. VAR     ScreenHandle:                 DeviceHandle;
  177.         ApId:                         GemHandle;
  178.         WindowHandle:                 CARDINAL;
  179.         CharWidth, CharHeight:        CARDINAL;
  180.         ScreenWidth, ScreenHeight:    CARDINAL;
  181.         LineHeight:                   CARDINAL;
  182.                                       
  183.         CharsInLine:                  CARDINAL;
  184.         LinesOnScreen:                CARDINAL;
  185.  
  186. (* Von EditBefehle *)
  187.         
  188. TYPE    einBefehl =
  189.  (nothing,
  190.  
  191.  (* Cursorbewegungen: *)
  192.   cursup, cursdown, cursleft, cursright,
  193.   Rollup, Rolldown, RollLeft, RollRight, RollFLeft, RollFRight,
  194.   Wortleft, Wortrigt, ZeilAnf, ZeilEnde,
  195.   Seitup, Seitdown, zumDAnf, zumDEnde, home, InsertBlank,
  196.   Bildoben, Bildunten,
  197.   tabulator, backtab, return,
  198.  
  199.  (* Maustasten: *)
  200.   LeftMous, RightMous,
  201.  
  202.  (* Suchen & Tauschen: *)
  203.   SuchString, StriTausch, SuchWort, WortTausch, PickWort, PickTausch,
  204.   WeitSuch, QueryError, (* naechste Compilerfehlermeldung *)
  205.   Lookup,
  206.  
  207.  (* Löschen/Einfügen: *)
  208.   DelLChar, DelRChar, DelLWort, DelRWort, DelBZeil, DelEZeil,
  209.   PopDeleteLine, PopCopyLine,
  210.   RestoreCurrentLine, CopyLastBufferLine, PopLastBufferLine, ZeilIns,
  211.   
  212.  (* Modus/Parameter: *)
  213.   insert, indent, TextProg, RandOffset, TabLaen,
  214.   TextParam, GlobParam, LoadParam, BackupAnlegen,
  215.   SteuerZeichenAnzeige,
  216.   Grossklein, Wortsuche,
  217.   
  218.  (* Marken, Goto: *)
  219.   set1Mark, set2Mark, set3Mark, zur1Mark, zur2Mark, zur3Mark,
  220.   setAMark, setEMark, zurAMark, zurEMark,
  221.   zuNrZeile, LetztePos, (* Letzte Editstelle *) LetzteSuchPos,
  222.   
  223.  (* Dynamische Merker: *)
  224.   MerkList, MerkPunkt, SetzList, SetzPunkt,
  225.   WaehleListe,
  226.  
  227.  (* Blockmarken/Operationen: *)
  228.   BlockMLoe, CopyToClipboard, CutToClipboard, DeleteBlock, Paste, Kopier,
  229.   Verschieb, GEMKlemmbrettEinAus, Einrueck, SelectWord, SelectLine,
  230.   SelectParagraph, SelectAll,
  231.  
  232.  (* Laden/Speichern/Löschen: *)
  233.   TextLoad, TextSave, BlockRead, BlockWrit, Update,
  234.   LoescheText,
  235.   TextFragLad, LoescheAllePuffer, SpeichereAllePuffer,
  236.   LoadFiles,
  237.   
  238.  (* Puffer setzen: *)
  239.   SetHelp, InsertPuff,
  240.   PufferWaehlen, NaechstenPuffer,
  241.   LoeschUndo, KillPuff, LoeschAlle,
  242.  
  243.  (* Metabefehle: *)
  244.   ExitEditor,
  245.   Quit, QuitCompile, QuitCompileRun, Compile, Make, MakeExec,
  246.   help, EditBlock,
  247.   TextVergleich, ZeitUndDatum,
  248.   CallFilebox (* Pfad ändern *), GMECopyrightBox,
  249.  
  250.  (* Verschiedene: *)
  251.   AsciiOrd,
  252.  
  253.   error);
  254.  
  255.         Befehlssatz =   SET OF einBefehl;
  256.  
  257. (* Von EditBuffer *)
  258.  
  259. PROCEDURE InitBuffer;
  260.  
  261. VAR     UndoPuffer:             einPufferPointer; (* eineZeile; *)
  262.         ClipBoard:              einPufferPointer;
  263.         HilfsPuffer:            einPufferPointer;
  264.         ConfigPuffer:           einPufferPointer;
  265.         EditPuffer:             einPufferPointer;
  266.         AlternEdit:             einPufferPointer;
  267.         DruckPuff:              einPufferPointer;
  268.         FehlerPuffer:           einPufferPointer;
  269.         MailPuffer:             einPufferPointer;
  270.         GolemPuffer:            einPufferPointer;
  271.         SendePuffer:            einPufferPointer;
  272.         Tausch:                 einPufferPointer;
  273.         PSCPuffer:              einPufferPointer;
  274.         LoadPuffer:             einPufferPointer;
  275.         DruckerBatch:           einPufferPointer;
  276.         TextVergleichP:         einPufferPointer;
  277.         WaehlPuffer:            einPufferPointer;
  278.         StartPuffer:            einPufferPointer;
  279.         Puffer1, Puffer2,
  280.         Puffer3, Puffer4:       einPufferPointer;
  281.         
  282.         undone:                 BOOLEAN;
  283.  
  284. (* Von KeyBase *)
  285.  
  286. CONST   cTastaturEbenen =       15;
  287.  
  288. CONST   MinScanCode =   1;
  289.         MaxScanCode =   131;
  290.  
  291.  
  292. TYPE    einStatusKey = (Shift, Control, Alternate, Caps,
  293.                         RMouse, LMouse);
  294.  
  295.         einStatus =     SET OF einStatusKey;
  296.  
  297.         einKey = (NoKey,
  298.         
  299.     (* Funktionstasten: *)
  300.   F1, F2, F3, F4, F5, F6, F7, F8, F9, F10,
  301.  
  302.     (* Tastaturblock: *)
  303.   TEsc, T1, T2, T3, T4, T5, T6, T7, T8, T9, T0, Tsz, TApo, TNum, TBackspace,
  304.   TTab, Tq, Tw, Te, Tr, Tt, Tz, Tu, Ti, To, Tp, Tue, TPlus, TRet, TDel,
  305.   Ta, Ts, Td, Tf, Tg, Th, Tj, Tk, Tl, Toe, Tae, TTild,
  306.   TGr, Ty, Tx, Tc, Tv, Tb, Tn, Tm, TKomma, TPunkt, TMinus,
  307.   TLeer,
  308.   
  309.     (* Cursorblock: *)
  310.   CHelp, CUndo, CInsert, CUp, CHome,
  311.   CLeft, CDown, CRight,
  312.   
  313.     (* Numerikblock: *)
  314.   NLeftp, NRightp, NSlash, NAsterix,
  315.   N7, N8, N9, NMinus,
  316.   N4, N5, N6, NPlus,
  317.   N1, N2, N3,
  318.   N0, NPoint, NEnter, KeyError);
  319.  
  320. TYPE    eineScanTabelle =  ARRAY [MinScanCode..MaxScanCode] OF einKey;
  321.  
  322. VAR     ScanTab:        eineScanTabelle;
  323.   
  324.   PROCEDURE KeyReady(): BOOLEAN;
  325.   PROCEDURE ReadKey (VAR k: einKey; VAR s: einStatus);
  326.   PROCEDURE KillKeyInput;
  327.   PROCEDURE TastInit;
  328.   PROCEDURE Init;
  329.   PROCEDURE TastReset;
  330.  
  331. (* ScreenBase *)
  332.  
  333. PROCEDURE GetVersion (VAR version: ARRAY OF CHAR);
  334.   
  335. PROCEDURE WrapOff;
  336. PROCEDURE WrapOn;
  337.  
  338. PROCEDURE WriteChar (c: CHAR);
  339. PROCEDURE WriteLine (REF s: ARRAY OF CHAR);
  340. (* schnelle Stringausgabe, kein LF *)
  341. PROCEDURE WriteConst (REF s: ARRAY OF CHAR);
  342.  
  343. PROCEDURE Trace (REF s: ARRAY OF CHAR);
  344. PROCEDURE WriteLn; (* CR + LF *)
  345. PROCEDURE InsertLn;
  346. PROCEDURE DeleteLn;
  347. PROCEDURE WhereXY (VAR x, y: CARDINAL);
  348. PROCEDURE GotoXY (x, y: CARDINAL);
  349. PROCEDURE CursorEin;
  350. PROCEDURE CursorAus;
  351. PROCEDURE CursorStumm;
  352. PROCEDURE CursorSchnell;
  353. PROCEDURE LoescheZeile;
  354. PROCEDURE LoescheBild;
  355. PROCEDURE LoescheEndeBild;
  356. PROCEDURE HighLight;
  357. PROCEDURE Normal;
  358.  
  359. PROCEDURE MausEin;
  360. PROCEDURE MausAus;
  361. PROCEDURE MausBusy;
  362.  
  363. PROCEDURE MausPos (VAR x, y: CARDINAL; VAR bewegt: BOOLEAN;
  364.                    VAR Knoepfe: ButtonSet);
  365.  
  366. PROCEDURE MausDoppel (VAR x, y: CARDINAL; VAR bewegt: BOOLEAN;
  367.                    VAR Knoepfe: ButtonSet);
  368.  
  369. PROCEDURE Nachricht (REF m: ARRAY OF CHAR);
  370. PROCEDURE FrageJaNein (default: CARDINAL; m: ARRAY OF CHAR): BOOLEAN;
  371. PROCEDURE Auswahl (VAR default: CARDINAL; m: ARRAY OF CHAR);
  372. PROCEDURE TopBox;
  373. PROCEDURE ClearAES;
  374.  
  375. (* Von EditBase *)
  376.  
  377. VAR     AutoCount:      CARDINAL;
  378. VAR     DoClipboard:    BOOLEAN;
  379.  
  380. PROCEDURE PuffInit (VAR Puff: einPufferPointer);
  381. PROCEDURE Loeschen (VAR Puff: einPufferPointer);
  382. PROCEDURE PufferLeer (Puff: einPufferPointer): BOOLEAN;
  383. PROCEDURE InsertPuffer (Puff: einPufferPointer): einPufferPointer;
  384. PROCEDURE FindeLeerpuffer (Puff: einPufferPointer): einPufferPointer;
  385. PROCEDURE DeletePuffer (VAR Puff: einPufferPointer);
  386. PROCEDURE GetLine (p: einLinePointer; VAR s: ARRAY OF CHAR);
  387.   (* Kopiere Zeileninhalt in String *)
  388. PROCEDURE PutConstLine (VAR p: einLinePointer; REF s: ARRAY OF CHAR);
  389. PROCEDURE PutLine (VAR p: einLinePointer;
  390.                    REF s: ARRAY OF CHAR);
  391.   (* Kopiere String in eine Zeile (Allocate optimiert) *)
  392. PROCEDURE DeAllocLine (VAR p: einLinePointer);
  393. PROCEDURE AllocLine (VAR p: einLinePointer; groesse: CARDINAL);
  394.  
  395. (************************** Von EditDirectory *****************)
  396.  
  397. PROCEDURE GetDirectory (VAR Pfad, FileName: ARRAY OF CHAR;
  398.                         Meldung: ARRAY OF CHAR;
  399.                         VAR Butt: INTEGER; GEM: BOOLEAN);
  400. PROCEDURE GetPfad (VAR pf: ARRAY OF CHAR);
  401. PROCEDURE DeleteTail (VAR s: ARRAY OF CHAR);
  402.  
  403. END GMEBase.
  404.  
  405. DEFINITION MODULE GMEConfig;
  406. (*$Z+*)
  407.  
  408. FROM GMEBase IMPORT
  409.   einKey, einStatus, cTastaturEbenen, einLinePointer, einPufferPointer,
  410.   einBefehl;
  411.  
  412. TYPE    einTastenTyp =          (keineTaste, Zeichen, Befehl, String,
  413.                                  Makro, Mausklick, Tastenebene);
  414.  
  415.         einTastaturPointer =    POINTER TO eineTastenEbene;
  416.         einMakroPointer =       POINTER TO einMakro;
  417.  
  418.         einTasteneintrag =      RECORD
  419.                                   CASE TT: einTastenTyp OF
  420.                                     keineTaste: |
  421.                                     Zeichen:    zch:    CHAR;|
  422.                                     Befehl:     bef:    einBefehl;|
  423.                                     String:     str:    einLinePointer;|
  424.                                     Makro:      mak:    einMakroPointer;|
  425.                                     Mausklick:  x, y:   CARDINAL;|
  426.                                     Tastenebene: teb:   einTastaturPointer;|
  427.                                   END (* CASE *);
  428.                                 END (* einTasteneintrag *);
  429.  
  430.         einMakro =              RECORD
  431.                                   makro:        einTasteneintrag;
  432.                                   next:         einMakroPointer;
  433.                                 END;
  434.  
  435.         eineTastenEbene =       ARRAY einKey OF einTasteneintrag;
  436.         eineTastatur =          ARRAY [0..cTastaturEbenen] OF einTastaturPointer;
  437.  
  438. VAR     Tastatur:               eineTastatur;
  439.         ConfigInit:     BOOLEAN;
  440.  
  441. PROCEDURE TastaturIndex (s: einStatus): CARDINAL;
  442. PROCEDURE NewTastenebene (VAR T: einTastaturPointer);
  443. PROCEDURE RemoveTastenebene (VAR T: einTastaturPointer);
  444. PROCEDURE InitTastenebene (keyStatus: einStatus; T: einTastaturPointer);
  445. PROCEDURE InitTastatur (VAR T: eineTastatur);
  446. PROCEDURE SetTaste (key: einKey; T: einTastaturPointer;
  447.                     eintrag: einTasteneintrag);
  448. PROCEDURE LiesTastMaus (VAR t: einTasteneintrag; keys: einStatus);
  449. PROCEDURE LiesBefehl (VAR b: einBefehl);
  450. PROCEDURE LiesTaste (VAR t: einTasteneintrag);
  451. PROCEDURE LiesZeichen (VAR ch: CHAR);
  452. PROCEDURE TasteBereit(): BOOLEAN;
  453. PROCEDURE LoescheQueue;
  454. PROCEDURE InitConfig (VAR Puff: einPufferPointer);
  455. PROCEDURE CopyConfig (VAR Q, Z: einPufferPointer);
  456.  
  457. END GMEConfig.
  458. *)
  459.  
  460. IMPLEMENTATION MODULE GMEConfig;
  461.  
  462. (*$Y+*)
  463. (*$R-*)
  464. (*$Z+*)
  465.  
  466. IMPORT EasyGEM0;
  467.  
  468. FROM SYSTEM IMPORT CAST, BYTE;
  469. FROM Granule IMPORT ALLOCATE, DEALLOCATE;
  470. FROM SystemError IMPORT OutOfMemory;
  471. FROM PrgCtrl IMPORT TermProcess, CatchProcessTerm, TermCarrier;
  472. FROM Paths IMPORT SearchFile, ListPos;
  473. FROM PathEnv IMPORT HomePath;
  474. FROM ShellMsg IMPORT StdPaths, ShellPath;
  475. FROM SysUtil0 IMPORT VarEqual;
  476. FROM UserBreak IMPORT DisableBreak;
  477. FROM KbdEvents IMPORT KbdEventsInstalled, InstallKbdEvents, DeInstallKbdEvents;
  478. FROM MOSGlobals IMPORT MemArea;
  479.  
  480. FROM AESResources IMPORT LoadResource, ResourcePart, ResourceAddr;
  481. FROM AESMenus IMPORT MenuBar, NormalTitle, CheckItem, EnableItem;
  482. FROM AESEvents IMPORT Event, EventSet, menuSelected, windRedraw, unspecMessage,
  483.   RectEnterMode, MessageBuffer, MultiEvent, KeyboardEvent;
  484. FROM AESWindows IMPORT UpdateWindow;
  485. FROM GEMGlobals IMPORT PtrObjTree, GemChar, MouseButton, MButtonSet,
  486.   SpecialKey, SpecialKeySet;
  487. FROM GEMEnv IMPORT GemError;
  488. FROM GrafBase IMPORT Point, Rectangle, Rect;
  489. FROM VDIInputs IMPORT GetMouseState;
  490. FROM GMEBase IMPORT MausEin, Nachricht, CursorAus, ClearAES,
  491.   ScreenHandle, WriteLine, WriteLn, WriteConst, WriteChar, GotoXY,
  492.   LoescheZeile;
  493.  
  494. FROM GMEBase IMPORT einKey, einStatus, einStatusKey, cTastaturEbenen,
  495.         ReadKey, KeyReady, KillKeyInput, ScanTab, eineScanTabelle;
  496.  
  497. FROM GMEBase IMPORT cRevision, cZeile, cTabWeite, cSchreibZaehler;
  498. FROM GMEBase IMPORT einLinePointer, CharSet, Mode, Moden, eineInfo,
  499.   einPufferPointer;
  500. FROM GMEBase IMPORT einBefehl;
  501. FROM GMEBase IMPORT EditPuffer, ClipBoard, ConfigPuffer;
  502. FROM GMEBase IMPORT PufferLeer;
  503.  
  504. FROM GMEBase IMPORT DoClipboard;
  505.  
  506. CONST   nul =   0C;
  507.  
  508. VAR     Menu:                   PtrObjTree;
  509.         noClicks:               CARDINAL;
  510.         butMask, butState:      MButtonSet;
  511.         moveDirec1, moveDirec2: RectEnterMode;
  512.         rect1Size, rect2Size:   Rectangle;
  513.         msg:                    MessageBuffer;
  514.         time:                   LONGCARD;
  515.         mouseLoc, oldLoc:       Point;
  516.         buttons:                MButtonSet;
  517.         keyState:               SpecialKeySet;
  518.         key:                    GemChar;
  519.         doneClicks:             CARDINAL;
  520.         occuredEvents:          EventSet;
  521.         MenuBefehl:             CARDINAL;
  522.  
  523. CONST
  524. (* Vom Resource Construction Set: *)
  525. (*
  526.         ACHTUNG!!!
  527.  
  528.    Wenn Sie die GEM-Resource-Datei ändern, müssen Sie aus dem
  529.    davon erzeugten D-Modul die nachfolgenden Konstanten neu
  530.    übernehmen. Beachten Sie auch die nachfolgende Initialisierung
  531.    der MenuTabelle und die Konstante "cMaxMenu" unten!!!
  532. *)
  533.  
  534. CONST
  535.   Gmemenue =   0;  (* Menuebaum *)
  536.   Deskmenu =   3;  (* TITLE in Baum GMEMENUE *)
  537.   Datemenu =   4;  (* TITLE in Baum GMEMENUE *)
  538.   Blockmen =   5;  (* TITLE in Baum GMEMENUE *)
  539.   Markmenu =   6;  (* TITLE in Baum GMEMENUE *)
  540.   Suchmenu =   7;  (* TITLE in Baum GMEMENUE *)
  541.   Editmenu =   8;  (* TITLE in Baum GMEMENUE *)
  542.   Programm =   9;  (* TITLE in Baum GMEMENUE *)
  543.   Golemedi =  12;  (* STRING in Baum GMEMENUE *)
  544.   Acc1     =  14;  (* STRING in Baum GMEMENUE *)
  545.   Acc2     =  15;  (* STRING in Baum GMEMENUE *)
  546.   Acc3     =  16;  (* STRING in Baum GMEMENUE *)
  547.   Acc4     =  17;  (* STRING in Baum GMEMENUE *)
  548.   Acc5     =  18;  (* STRING in Baum GMEMENUE *)
  549.   Acc6     =  19;  (* STRING in Baum GMEMENUE *)
  550.   Neuertex =  22;  (* STRING in Baum GMEMENUE *)
  551.   Laden    =  23;  (* STRING in Baum GMEMENUE *)
  552.   Bllesen  =  24;  (* STRING in Baum GMEMENUE *)
  553.   Sichern  =  26;  (* STRING in Baum GMEMENUE *)
  554.   Speicher =  27;  (* STRING in Baum GMEMENUE *)
  555.   Blspeich =  28;  (* STRING in Baum GMEMENUE *)
  556.   Textloes =  29;  (* STRING in Baum GMEMENUE *)
  557.   Konfigea =  31;  (* STRING in Baum GMEMENUE *)
  558.   Backupan =  32;  (* STRING in Baum GMEMENUE *)
  559.   Konfigsi =  34;  (* STRING in Baum GMEMENUE *)
  560.   Qallsave =  35;  (* STRING in Baum GMEMENUE *)
  561.   Ende     =  36;  (* STRING in Baum GMEMENUE *)
  562.   Blcut    =  38;  (* STRING in Baum GMEMENUE *)
  563.   Blversch =  39;  (* STRING in Baum GMEMENUE *)
  564.   Blkkopie =  40;  (* STRING in Baum GMEMENUE *)
  565.   Bledit   =  41;  (* STRING in Baum GMEMENUE *)
  566.   Blanfang =  43;  (* STRING in Baum GMEMENUE *)
  567.   Blende   =  44;  (* STRING in Baum GMEMENUE *)
  568.   Zeilmark =  45;  (* STRING in Baum GMEMENUE *)
  569.   Allmark  =  46;  (* STRING in Baum GMEMENUE *)
  570.   Gemscrap =  48;  (* STRING in Baum GMEMENUE *)
  571.   Setzema1 =  50;  (* STRING in Baum GMEMENUE *)
  572.   Setzema2 =  51;  (* STRING in Baum GMEMENUE *)
  573.   Setzema3 =  52;  (* STRING in Baum GMEMENUE *)
  574.   Zumarke1 =  53;  (* STRING in Baum GMEMENUE *)
  575.   Zumarke2 =  54;  (* STRING in Baum GMEMENUE *)
  576.   Zumarke3 =  55;  (* STRING in Baum GMEMENUE *)
  577.   Zeilennr =  57;  (* STRING in Baum GMEMENUE *)
  578.   Letztepo =  58;  (* STRING in Baum GMEMENUE *)
  579.   Fehlerme =  60;  (* STRING in Baum GMEMENUE *)
  580.   Wortsuch =  62;  (* STRING in Baum GMEMENUE *)
  581.   Grosskle =  63;  (* STRING in Baum GMEMENUE *)
  582.   Suche    =  65;  (* STRING in Baum GMEMENUE *)
  583.   Tausche  =  66;  (* STRING in Baum GMEMENUE *)
  584.   Pickwort =  67;  (* STRING in Baum GMEMENUE *)
  585.   Picktaus =  68;  (* STRING in Baum GMEMENUE *)
  586.   Nochmsuc =  69;  (* STRING in Baum GMEMENUE *)
  587.   Overwrit =  71;  (* STRING in Baum GMEMENUE *)
  588.   Autoinde =  72;  (* STRING in Baum GMEMENUE *)
  589.   Next     =  74;  (* STRING in Baum GMEMENUE *)
  590.   Help     =  75;  (* STRING in Baum GMEMENUE *)
  591.   Bleinrue =  77;  (* STRING in Baum GMEMENUE *)
  592.   Mcompile =  79;  (* STRING in Baum GMEMENUE *)
  593.   Datum    =  80;  (* STRING in Baum GMEMENUE *)
  594.   Compilie =  82;  (* STRING in Baum GMEMENUE *)
  595.   Comprun  =  83;  (* STRING in Baum GMEMENUE *)
  596.   Qmake    =  84;  (* STRING in Baum GMEMENUE *)
  597.   Makeexec =  85;  (* STRING in Baum GMEMENUE *)
  598.   Gmeinfo  =   1;  (* Formular/Dialog *)
  599.   Version  =   5;  (* STRING in Baum GMEINFO *)
  600. (* ***************************************** *)
  601.  
  602. CONST   cMaxMenu =              86;
  603. VAR     MenuTabelle:            ARRAY [0..cMaxMenu] OF einBefehl;
  604.  
  605. PROCEDURE InitMenuTabelle;
  606. BEGIN
  607.  
  608. (* GME                *) MenuTabelle [Deskmenu] := nothing;
  609. (* ================== *)
  610. (* Der Golemeditor    *) MenuTabelle [Golemedi] := GMECopyrightBox;
  611. (* ------------------ *)
  612. (*    Accessories     *) MenuTabelle [Acc1    ] := nothing;
  613. (*                    *) MenuTabelle [Acc2    ] := nothing;
  614. (*                    *) MenuTabelle [Acc3    ] := nothing;
  615. (*                    *) MenuTabelle [Acc4    ] := nothing;
  616. (*                    *) MenuTabelle [Acc5    ] := nothing;
  617. (*    Accessories     *) MenuTabelle [Acc6    ] := nothing;
  618.  
  619. (* Datei              *) MenuTabelle [Datemenu] := nothing;
  620. (* ================== *)
  621. (* Konfiguration spei *) MenuTabelle [Konfigea] := TextParam;
  622. (* ------------------ *)
  623. (* Neu                *) MenuTabelle [Neuertex] := InsertPuff;
  624. (* Öffnen             *) MenuTabelle [Laden   ] := TextLoad;
  625. (* Einfügen           *) MenuTabelle [Bllesen ] := BlockRead;
  626. (* ------------------ *)
  627. (* Sichern            *) MenuTabelle [Sichern ] := Update;
  628. (* Sichern mit Frage  *) MenuTabelle [Speicher] := TextSave;
  629. (* Block Sichern...   *) MenuTabelle [Blspeich] := BlockWrit;
  630. (* Schließen          *) MenuTabelle [Textloes] := LoescheText;
  631. (* ------------------ *)
  632. (* Backup anlegen     *) MenuTabelle [Backupan] := BackupAnlegen;
  633. (* Parameter Sichern  *) MenuTabelle [Konfigsi] := GlobParam;
  634. (* Quit alles Sichern *) MenuTabelle [Qallsave] := SpeichereAllePuffer;
  635. (* Beenden            *) MenuTabelle [Ende    ] := ExitEditor;
  636.  
  637. (* Block              *) MenuTabelle [Blockmen] := nothing;
  638. (* ================== *)
  639. (* Ausschneiden       *) MenuTabelle [Blcut   ] := CutToClipboard;
  640. (* Merken             *) MenuTabelle [Blversch] := CopyToClipboard;
  641. (* Einfügen           *) MenuTabelle [Blkkopie] := Paste;
  642. (* Editieren          *) MenuTabelle [Bledit  ] := EditBlock;
  643. (* ------------------ *)
  644. (* Anfang markieren   *) MenuTabelle [Blanfang] := setAMark;
  645. (* Ende markieren     *) MenuTabelle [Blende  ] := setEMark;
  646. (* Wort markieren     MenuTabelle [Wortmark] := SelectWord; *)
  647. (* Zeile markieren    *) MenuTabelle [Zeilmark] := SelectLine;
  648. (* Alles markieren    *) MenuTabelle [Allmark ] := SelectAll;
  649. (* ------------------ *)
  650. (* GEM-Klemmbrett     *) MenuTabelle [Gemscrap] := GEMKlemmbrettEinAus;
  651.  
  652. (* Marken             *) MenuTabelle [Markmenu] := nothing;
  653. (* ================== *)
  654. (* Setze Marke 1      *) MenuTabelle [Setzema1] := set1Mark;
  655. (* Setze Marke 2      *) MenuTabelle [Setzema2] := set2Mark;
  656. (* Setze Marke 3      *) MenuTabelle [Setzema3] := set3Mark;
  657. (* Zu Marke 1         *) MenuTabelle [Zumarke1] := zur1Mark;
  658. (* Zu Marke 2         *) MenuTabelle [Zumarke2] := zur2Mark;
  659. (* Zu Marke 3         *) MenuTabelle [Zumarke3] := zur3Mark;
  660. (* ------------------ *)
  661. (* Zu Zeilennummer    *) MenuTabelle [Zeilennr] := zuNrZeile;
  662. (* Letzte Position    *) MenuTabelle [Letztepo] := LetztePos;
  663. (* ------------------ *)
  664. (* Zur Fehlermeldung  *) MenuTabelle [Fehlerme] := QueryError;
  665.  
  666. (* Suchen             *) MenuTabelle [Suchmenu] := nothing;
  667. (* ================== *)
  668. (* Grossklein         *) MenuTabelle [Grosskle] := Grossklein;
  669. (* Wort suchen        *) MenuTabelle [Wortsuch] := Wortsuche;
  670. (* ------------------ *)
  671. (* Suchen...          *) MenuTabelle [Suche   ] := SuchString;
  672. (* Tauschen...        *) MenuTabelle [Tausche ] := StriTausch;
  673. (* Pick Wort          *) MenuTabelle [Pickwort] := PickWort;
  674. (* Pick Tauschen      *) MenuTabelle [Picktaus] := PickTausch;
  675. (* Nochmal Suchen     *) MenuTabelle [Nochmsuc] := WeitSuch;
  676.  
  677. (* Editieren          *) MenuTabelle [Editmenu] := nothing;
  678. (* ================== *)
  679. (* Überschreiben      *) MenuTabelle [Overwrit] := insert;
  680. (* Automatisch Einrück*) MenuTabelle [Autoinde] := indent;
  681. (* ------------------ *)
  682. (* Nächster Text      *) MenuTabelle [Next    ] := NaechstenPuffer;
  683. (* Hintergrund        *) MenuTabelle [Help    ] := help;
  684. (* ------------------ *)
  685. (* Block Einrücken    *) MenuTabelle [Bleinrue] := Einrueck;
  686.  
  687. (*
  688. (* Bildschirm         *) MenuTabelle [Bildschi] := nothing;
  689. (* ------------------ *)
  690. (* Hochrollen         *) MenuTabelle [Scrollup] := Rollup;
  691. (* Runterrollen       *) MenuTabelle [Scroldow] := Rolldown;
  692. (* ------------------ *)
  693. (* Wort links         *) MenuTabelle [Wortlink] := Wortleft;
  694. (* Wort rechts        *) MenuTabelle [Wortrech] := Wortrigt;
  695. (* Zeilenanfang       *) MenuTabelle [Zeilanfa] := ZeilAnf;
  696. (* Zeilenende         *) MenuTabelle [Zeilende] := ZeilEnde;
  697. (* Seite nach oben    *) MenuTabelle [Seithoch] := Seitup;
  698. (* Seite nach unten   *) MenuTabelle [Seitrunt] := Seitdown;
  699. (* Zum Textanfang     *) MenuTabelle [Ctextanf] := zumDAnf;
  700. (* Zum Textende       *) MenuTabelle [Ctextend] := zumDEnde;
  701. *)
  702.  
  703. (* Programm           *) MenuTabelle [Programm] := nothing;
  704. (* ------------------ *)
  705. (* Compilieren        *) MenuTabelle [Mcompile] := Compile;
  706. (* Make               *) MenuTabelle [Qmake   ] := Make;
  707. (* Make & Run         *) MenuTabelle [Makeexec] := MakeExec;
  708. (* Datum              *) MenuTabelle [Datum   ] := ZeitUndDatum;
  709. (* ------------------ *)
  710. (* Q-Compilieren      *) MenuTabelle [Compilie] := QuitCompile;
  711. (* Q-Comp. & Run      *) MenuTabelle [Comprun ] := QuitCompileRun;
  712.  
  713. END InitMenuTabelle;
  714.  
  715. PROCEDURE CopyConfig (VAR Q, Z: einPufferPointer);
  716. BEGIN
  717.   WITH Z^ DO
  718.     MagicRevision := cRevision;
  719.     Modus := Q^.Modus;
  720.     Max := Q^.Max;
  721.     TabWeite := Q^.TabWeite;
  722.     SchreibZaehler := Q^.SchreibZaehler;
  723.   END (* WITH *);
  724. END CopyConfig;
  725.  
  726. (* Die folgende Prozedur bestimmt die Einstellung des Editors beim Start. *)
  727.  
  728. PROCEDURE InitConfig (VAR Puff: einPufferPointer);
  729. BEGIN
  730.   IF ~ConfigInit THEN
  731.     WITH Puff^ DO
  732.       MagicRevision := cRevision;
  733. (*
  734.       (* Beispiel 1: Automatisch einrücken, BAK-Datei erzeugen *)
  735.       Modus := Moden {ControlZeichen, AutoIndent, TabFiltern, MakeBAK};
  736. *)
  737.       (* Beispiel 2: Außerdem Konfiguration laden u. zu Texten speichern *
  738.        *             keine BAK-Datei erzeugen                            *)
  739.       Modus := Moden {ControlZeichen, AutoIndent, TabFiltern,
  740.                       KonfigSpeichern, WortSuche};
  741.       Pfad := ''; Name := '';
  742.       Max := cZeile;
  743.       TabWeite := cTabWeite;
  744.       SchreibZaehler := cSchreibZaehler;
  745.     END (* WITH *);
  746.   ELSE
  747.     WITH Puff^ DO
  748.       MagicRevision := cRevision;
  749.       Modus := ConfigPuffer^.Modus;
  750.       Pfad := ConfigPuffer^.Pfad; (* ??? *)
  751.       Name := '';
  752.       Max := ConfigPuffer^.Max;
  753.       TabWeite := ConfigPuffer^.TabWeite;
  754.       SchreibZaehler := ConfigPuffer^.SchreibZaehler;
  755.     END (* WITH *);
  756.   END (* IF ConfigInit *);
  757. END InitConfig;
  758.  
  759.  
  760. PROCEDURE ShowGMEInfo;
  761.   VAR button: CARDINAL;
  762.   BEGIN
  763.     EasyGEM0.DoSimpleBox (ResourceAddr (treeRsrc, Gmeinfo),
  764.       Rect (-1,-1,-1,-1), button);
  765.   END ShowGMEInfo;
  766.  
  767. PROCEDURE TasteBereit(): BOOLEAN;
  768. BEGIN RETURN (* KeyReady() *) TRUE; END TasteBereit;
  769.  
  770. PROCEDURE LoescheQueue;
  771. VAR     k: einKey;
  772.         localEvents: EventSet;
  773. BEGIN
  774.   (* UpdateWindow (FALSE); *)
  775.   REPEAT
  776.     (* KeyBoardEvent (key); *)
  777.     (* hm... wie soll das gehen, ehe ich nicht weiß, ob noch
  778.        KeyBoardEvents anhängig sind??? *)
  779.     MultiEvent (EventSet {keyboard, timer},
  780.                 0, butMask, butState,
  781.                 moveDirec1, rect1Size,
  782.                 moveDirec2, rect2Size,
  783.                 msg, time, mouseLoc, buttons,
  784.                 keyState, key, doneClicks, localEvents);
  785.     
  786.   UNTIL ~(keyboard IN localEvents);
  787.   (* UpdateWindow (TRUE); *)
  788. END LoescheQueue;
  789.  
  790. PROCEDURE TastaturIndex (s: einStatus): CARDINAL;
  791. CONST   cTastaturLimit =        cTastaturEbenen + 1;
  792. BEGIN
  793.   RETURN ORD (CAST (BYTE, s)) MOD cTastaturLimit;
  794. END TastaturIndex;
  795.  
  796. PROCEDURE StatusVonKeySet (ks: SpecialKeySet): einStatus;
  797. (* Oh Gott - dies ev. in Atzempler machen - oder wie??? *)
  798. VAR     c:      CARDINAL;
  799. BEGIN
  800.   c := ORD (CAST (BYTE, ks)) DIV 2;
  801.   IF ODD (ORD (CAST (BYTE, ks))) THEN INC (c); END;
  802.   RETURN CAST (einStatus, c);
  803. END StatusVonKeySet;
  804.  
  805. PROCEDURE NewTastenebene (VAR T: einTastaturPointer);
  806. BEGIN
  807.   NEW (T);
  808.   IF T = NIL THEN OutOfMemory END;
  809. END NewTastenebene;
  810.  
  811. PROCEDURE RemoveTastenebene (VAR T: einTastaturPointer);
  812. BEGIN
  813.   IF T # NIL THEN DISPOSE (T); END;
  814. END RemoveTastenebene;
  815.  
  816. PROCEDURE SetTaste (key: einKey; T: einTastaturPointer;
  817.                     eintrag: einTasteneintrag);
  818. BEGIN
  819.   T^ [key] := eintrag;
  820. END SetTaste;
  821.  
  822. PROCEDURE ShiftAscii (keyStatus: einStatus; ch: CHAR): CHAR;
  823. BEGIN
  824.   IF (Caps IN keyStatus) & (ch IN CharSet {'a'..'z', 'ä', 'ö', 'ü'}) THEN
  825.                 (* Hier fehlen ev. noch kleine Zeichen mit Akzenten... *)
  826.     (* das kann MM2 besser:
  827.       IF ((ch >= 'a') & (ch <= 'z'))
  828.       THEN ch := CHR (ORD (ch) - 32);
  829.       ELSE CASE ch OF
  830.         'ä':      ch := 'Ä';|
  831.         'ö':      ch := 'Ö';|
  832.         'ü':      ch := 'Ü';|
  833.         ELSE;
  834.         END (* CASE *);
  835.       END (* IF *);
  836.       RETURN ch;
  837.     *)
  838.     RETURN CAP (ch)
  839.   END;
  840.   IF Shift IN keyStatus THEN
  841.     (* auch hier müßte CAP besser tun:
  842.       ch := CHR (ORD (ch) - 32);
  843.       RETURN ch;
  844.     *)
  845.     RETURN CAP (ch)
  846.   END;
  847.   IF Control IN keyStatus THEN
  848.     RETURN CHR (ORD (ch) - 96);
  849.   END;
  850.   RETURN ch;
  851. END ShiftAscii;
  852.  
  853. PROCEDURE InitFunktionstasten (keyStatus: einStatus; T: einTastaturPointer);
  854. VAR     key:    einKey;
  855.  
  856.   PROCEDURE SetzF (f1, f2, f3, f4, f5, f6, f7, f8, f9, f0: einBefehl);
  857.   BEGIN
  858.     T^ [F1].bef := f1;
  859.     T^ [F2].bef := f2;
  860.     T^ [F3].bef := f3;
  861.     T^ [F4].bef := f4;
  862.     T^ [F5].bef := f5;
  863.     T^ [F6].bef := f6;
  864.     T^ [F7].bef := f7;
  865.     T^ [F8].bef := f8;
  866.     T^ [F9].bef := f9;
  867.     T^ [F10].bef := f0;
  868.   END SetzF;
  869.   
  870.   PROCEDURE SetzC (Esc, Tab, Backspace, Delete, Return,
  871.         Help, Undo, Insert, Up, Home, Left, Down, Right: einBefehl);
  872.   BEGIN
  873.     T^ [TEsc       ].bef := Esc;
  874.     T^ [TTab       ].bef := Tab;
  875.     T^ [TBackspace ].bef := Backspace;
  876.     T^ [TDel       ].bef := Delete;
  877.     T^ [TRet       ].bef := Return;
  878.     T^ [NEnter     ].bef := Return;
  879.     T^ [CHelp      ].bef := Help;
  880.     T^ [CUndo      ].bef := Undo;
  881.     T^ [CInsert    ].bef := Insert;
  882.     T^ [CUp        ].bef := Up;
  883.     T^ [CHome      ].bef := Home;
  884.     T^ [CLeft      ].bef := Left;
  885.     T^ [CDown      ].bef := Down;
  886.     T^ [CRight     ].bef := Right;
  887.   END SetzC;
  888.  
  889. BEGIN (* InitFunktionstasten *)
  890.   FOR key := F1 TO F10 DO
  891.     WITH T^ [key] DO
  892.       TT := Befehl;
  893.     END (* WITH *);
  894.   END (* FOR *);
  895.   FOR key := CHelp TO CRight DO
  896.     WITH T^ [key] DO
  897.       TT := Befehl;
  898.     END (* WITH *);
  899.   END (* FOR *);
  900.   T^ [TEsc      ].TT := Befehl;
  901.   T^ [TTab      ].TT := Befehl;
  902.   T^ [TBackspace].TT := Befehl;
  903.   T^ [TDel      ].TT := Befehl;
  904.   T^ [TRet      ].TT := Befehl;
  905.   T^ [NEnter    ].TT := Befehl;
  906.   IF (keyStatus = einStatus {}) OR (keyStatus = einStatus {Caps}) THEN
  907.     SetzF (SuchString, StriTausch, PickWort, WeitSuch, nothing,
  908.            Paste, zurAMark, zurEMark, zur1Mark, zur2Mark);
  909.     SetzC (Quit, tabulator, DelLChar, DelRChar, return,
  910.            help, RestoreCurrentLine,
  911.            insert, cursup, PopCopyLine,
  912.            cursleft, cursdown, cursright);
  913.   ELSIF (keyStatus = einStatus {Shift}) OR (keyStatus = einStatus {Shift, Caps}) THEN
  914.     SetzF (SuchWort, WortTausch, PickTausch, zuNrZeile, QueryError,
  915.            CopyToClipboard, setAMark, setEMark, set1Mark, set2Mark);
  916.     SetzC (QuitCompile, backtab, DelLWort, DelRWort, return,
  917.            EditBlock, CopyLastBufferLine,
  918.            indent, Seitup, PopDeleteLine,
  919.            Wortleft, Seitdown, Wortrigt);
  920.     T^ [NMinus].TT := Befehl; T^ [NMinus].bef := Rolldown;
  921.     T^ [NPlus].TT := Befehl;  T^ [NPlus].bef := Rollup;
  922.   ELSIF (keyStatus = einStatus {Control}) OR (keyStatus = einStatus {Control, Caps}) THEN
  923.     SetzC (QuitCompileRun, ZeilEnde, DelBZeil, DelEZeil, return,
  924.            nothing, PopLastBufferLine,
  925.            Paste, zumDAnf, DeleteBlock,
  926.            ZeilAnf, zumDEnde, ZeilEnde);
  927.   ELSIF (keyStatus = einStatus {Alternate}) OR (keyStatus = einStatus {Alternate, Caps}) THEN
  928.     SetzC (Quit, tabulator, DelLChar, PopDeleteLine, return,
  929.            help, RestoreCurrentLine,
  930.            PopCopyLine, cursup, home,
  931.            cursleft, cursdown, cursright);
  932.   END (* IF *);
  933. END InitFunktionstasten;
  934.  
  935. PROCEDURE InitTastenebene (keyStatus: einStatus; T: einTastaturPointer);
  936. VAR     key:    einKey;
  937.         ch:     CHAR;
  938. BEGIN
  939.   (* Vorinitialisierung: *)
  940.   FOR key := NoKey TO KeyError DO
  941.     WITH T^ [key] DO
  942.       TT := Zeichen; zch := nul;
  943.     END (* WITH *);
  944.   END (* FOR *);
  945. END InitTastenebene;
  946.  
  947. PROCEDURE SetControl (t: einTastaturPointer;
  948.                       k: einKey; b: einBefehl);
  949. BEGIN
  950.   WITH t^[k] DO
  951.     TT := Befehl; bef := b;
  952.   END (* WITH *);
  953. END SetControl;
  954.  
  955.  
  956. PROCEDURE CtrlZeich (t: einTastaturPointer; k: einKey);
  957. BEGIN
  958.   NewTastenebene (t^ [k].teb); t^ [k].TT := Tastenebene;
  959.   InitTastenebene (einStatus {Control}, t^ [k].teb);
  960. END CtrlZeich;
  961.  
  962. PROCEDURE CtrlKEbene (t: einTastaturPointer; k: einKey);
  963. BEGIN
  964.   NewTastenebene (t^ [k].teb); t^ [k].TT := Tastenebene;
  965.   InitTastenebene (einStatus {}, t^ [k].teb);
  966.   WITH t^ [k] DO
  967.     SetControl (teb, T1, set1Mark);
  968.     SetControl (teb, T2, set2Mark);
  969.     SetControl (teb, T3, set3Mark);
  970.     SetControl (teb, Ta, SpeichereAllePuffer);
  971.     SetControl (teb, Tb, setAMark);
  972.     SetControl (teb, Tc, Kopier);
  973.     SetControl (teb, Td, TextSave);
  974.     SetControl (teb, Te, Einrueck);
  975.     SetControl (teb, Tf, TextParam);
  976.     SetControl (teb, Tg, DeleteBlock);
  977.     SetControl (teb, Th, BlockMLoe);
  978.     SetControl (teb, Ti, SelectAll);
  979.     SetControl (teb, Tj, LoadParam);
  980.     SetControl (teb, Tk, setEMark);
  981.     SetControl (teb, Tl, TextLoad);
  982.     SetControl (teb, Tm, CopyToClipboard);
  983.     SetControl (teb, Tn, InsertPuff);
  984.     SetControl (teb, To, EditBlock);
  985.     SetControl (teb, Tp, GlobParam);
  986.     SetControl (teb, Tq, ExitEditor);
  987.     SetControl (teb, Tr, BlockRead);
  988.     SetControl (teb, Ts, Update);
  989.     SetControl (teb, Tt, SelectWord);
  990.     SetControl (teb, Tu, TextParam);
  991.     SetControl (teb, Tv, Verschieb);
  992.     SetControl (teb, Tw, BlockWrit);
  993.     SetControl (teb, Tx, QuitCompile);
  994.     SetControl (teb, Ty, CutToClipboard);
  995.     SetControl (teb, Tz, SelectLine);
  996.   END (* WITH *);
  997. END CtrlKEbene;
  998.  
  999. PROCEDURE CtrlOEbene (t: einTastaturPointer; k: einKey);
  1000. BEGIN
  1001.   NewTastenebene (t^ [k].teb); t^ [k].TT := Tastenebene;
  1002.   InitTastenebene (einStatus {}, t^ [k].teb);
  1003.   WITH t^ [k] DO
  1004.     SetControl (teb, Ta, RollFLeft);
  1005.     SetControl (teb, Td, SteuerZeichenAnzeige);
  1006.     SetControl (teb, Tf, RollFRight);
  1007.     SetControl (teb, Tg, indent);
  1008.     SetControl (teb, Ti, TabLaen);
  1009.     SetControl (teb, Ty, LoescheText);
  1010.     SetControl (teb, Tz, LoescheAllePuffer);
  1011.   END (* WITH *);
  1012. END CtrlOEbene;
  1013.  
  1014. PROCEDURE CtrlQEbene (t: einTastaturPointer; k: einKey);
  1015. BEGIN
  1016.   NewTastenebene (t^ [k].teb); t^ [k].TT := Tastenebene;
  1017.   InitTastenebene (einStatus {}, t^ [k].teb);
  1018.   WITH t^ [k] DO
  1019.     SetControl (teb, T1, zur1Mark);
  1020.     SetControl (teb, T2, zur2Mark);
  1021.     SetControl (teb, T3, zur3Mark);
  1022.     SetControl (teb, Ta, StriTausch);
  1023.     SetControl (teb, Tb, zurAMark);
  1024.     SetControl (teb, Tc, zumDEnde);
  1025.     SetControl (teb, Td, ZeilEnde);
  1026.     SetControl (teb, Te, QueryError);
  1027.     SetControl (teb, Tf, SuchString);
  1028.     SetControl (teb, Tg, Grossklein);
  1029.     SetControl (teb, Ti, PickWort);
  1030.     SetControl (teb, Tj, LoadParam);
  1031.     SetControl (teb, Tk, zurEMark);
  1032.     SetControl (teb, Tn, zuNrZeile);
  1033.     SetControl (teb, To, PickTausch);
  1034.     SetControl (teb, Tp, LetztePos);
  1035.     SetControl (teb, Tr, zumDAnf);
  1036.     SetControl (teb, Ts, ZeilAnf);
  1037.     SetControl (teb, Tt, Wortsuche);
  1038.     SetControl (teb, Tv, LetzteSuchPos);
  1039.     SetControl (teb, Tw, SuchWort);
  1040.     SetControl (teb, Tq, WortTausch);
  1041.     SetControl (teb, Ty, DelEZeil);
  1042.   END (* WITH *);
  1043. END CtrlQEbene;
  1044.  
  1045. PROCEDURE InitControl (T: einTastaturPointer);
  1046.   (* Einfache Control-Befehle: *)
  1047. BEGIN
  1048.   (* obere Tastenreihe *)
  1049.   CtrlQEbene (T, Tq);
  1050.   SetControl (T, Tw,      Rollup);
  1051.   SetControl (T, Te,      cursup);
  1052.   SetControl (T, Tr,      Seitup);
  1053.   SetControl (T, Tt,      DelRWort);
  1054.   SetControl (T, Tz,      Rolldown);
  1055.   SetControl (T, Tu,      RestoreCurrentLine);
  1056.   SetControl (T, Ti,      tabulator);
  1057.   CtrlOEbene (T, To);
  1058.   CtrlZeich  (T, Tp);     (* Controlzeichen eingeben *)
  1059.  
  1060.   (* mittlere Tastenreihe *)
  1061.   SetControl (T, Ta,      Wortleft);
  1062.   SetControl (T, Ts,      cursleft);
  1063.   SetControl (T, Td,      cursright);
  1064.   SetControl (T, Tf,      Wortrigt);
  1065.   SetControl (T, Tg,      DelRChar);
  1066.   SetControl (T, Th,      DelLChar);
  1067.   SetControl (T, Tj,      NaechstenPuffer);
  1068.   CtrlKEbene (T, Tk);
  1069.   SetControl (T, Tl,      WeitSuch);
  1070.  
  1071.   (* untere Tastenreihe *)
  1072.   SetControl (T, Ty,      PopDeleteLine);
  1073.   SetControl (T, Tx,      CutToClipboard);
  1074.   SetControl (T, Tc,      CopyToClipboard);
  1075.   SetControl (T, Tv,      Paste);
  1076.   SetControl (T, Tb,      nothing);
  1077.   SetControl (T, Tn,      AsciiOrd);
  1078. END InitControl;
  1079.  
  1080. PROCEDURE InitAlternate (T: einTastaturPointer);
  1081. BEGIN
  1082.   SetControl (T, Ta,      QuitCompileRun); (* Speichern und RETURN 2 *)
  1083.   SetControl (T, Tc,      QuitCompile); (* = Compilieren aus d. Editor! *)
  1084.   SetControl (T, Td,      Compile); (* Im Speicher compilieren *)
  1085.   SetControl (T, Tm,      Make); (* RETURN 3 *)
  1086.   SetControl (T, Tr,      MakeExec); (* Quit Return 4 *)
  1087.   SetControl (T, Tt,      ZeitUndDatum);
  1088.   SetControl (T, Tx,      ExitEditor);
  1089. END InitAlternate;
  1090.  
  1091. PROCEDURE InitTastatur (VAR T: eineTastatur);
  1092. VAR     index:  CARDINAL;
  1093. BEGIN
  1094.   FOR index := 0 TO cTastaturEbenen DO
  1095.     NewTastenebene (T [index]);
  1096.     InitTastenebene (CAST (einStatus, index), T [index]);
  1097.     InitFunktionstasten (CAST (einStatus, index), T [index]);
  1098.   END (* FOR *);
  1099.   InitControl (T [ORD (CAST (BYTE, einStatus {Control}))]);
  1100.   InitAlternate (T [ORD (CAST (BYTE, einStatus {Alternate}))]);
  1101. END InitTastatur;
  1102.  
  1103. VAR     OldModus:       Moden;
  1104.         firstCommand, oldRight, rightButton: BOOLEAN;
  1105.         OldClipLeer, OldDoClipboard, OldNextPuff: BOOLEAN;
  1106.  
  1107. PROCEDURE LiesTaste (VAR t: einTasteneintrag);
  1108. TYPE    CharSet =  SET OF CHAR;
  1109. VAR     k:      einKey;
  1110.         s:      einStatus;
  1111.         n:      CARDINAL;
  1112.         tt:     einTasteneintrag;
  1113.         localEvents: EventSet;
  1114.         
  1115. BEGIN
  1116.   (* Häkchen updaten... *)
  1117.   WITH EditPuffer^ DO
  1118.     IF OldModus <> Modus THEN
  1119.       OldModus := Modus;
  1120.       CheckItem (Menu, Backupan, MakeBAK IN Modus);
  1121.       CheckItem (Menu, Konfigea, KonfigSpeichern IN Modus);
  1122.       CheckItem (Menu, Grosskle, GrossKleinSuche IN Modus);
  1123.       CheckItem (Menu, Wortsuch, WortSuche IN Modus);
  1124.       CheckItem (Menu, Autoinde, AutoIndent IN Modus);
  1125.       CheckItem (Menu, Overwrit, OverWrite IN Modus);
  1126.     END (* IF *);
  1127.     IF (OldDoClipboard # DoClipboard)
  1128.     OR (OldClipLeer # PufferLeer (ClipBoard)) THEN
  1129.       OldClipLeer:= PufferLeer (ClipBoard);
  1130.       EnableItem (Menu, Blkkopie, DoClipboard OR ~OldClipLeer)
  1131.     END;
  1132.     IF OldDoClipboard # DoClipboard THEN
  1133.       OldDoClipboard:= DoClipboard;
  1134.       CheckItem (Menu, Gemscrap, DoClipboard)
  1135.     END;
  1136.     IF OldNextPuff # (EditPuffer^.NaechsterPuffer # EditPuffer) THEN
  1137.       OldNextPuff:= (EditPuffer^.NaechsterPuffer # EditPuffer);
  1138.       EnableItem (Menu, Next, OldNextPuff)
  1139.     END;
  1140.   END (* WITH *);
  1141.   
  1142.   UpdateWindow (FALSE);
  1143.   
  1144.   t.TT := keineTaste;
  1145.   REPEAT
  1146.   (* Schleife zur Eventabfrage. Die Schleife wird nur verlassen, wenn
  1147.      ein für den Editor relevanter Event aufgetreten ist. Das ist
  1148.      entweder ein Tastendruck (keyboard), eine Maustaste (mouseButton)
  1149.      oder eine Auswahl aus der Menuleiste (message): *)
  1150.     
  1151.     IF occuredEvents = EventSet {} THEN
  1152.       MultiEvent (EventSet {keyboard, mouseButton, message, timer},
  1153.                   noClicks, butMask, butState,
  1154.                   moveDirec1, rect1Size,
  1155.                   moveDirec2, rect2Size,
  1156.                   msg, time, mouseLoc, buttons,
  1157.                   keyState, key, doneClicks, occuredEvents);
  1158.     END;
  1159.  
  1160.     IF NOT VarEqual (mouseLoc, oldLoc) THEN
  1161.       MausEin; oldLoc := mouseLoc;
  1162.     END;
  1163.     
  1164.     (* AES verweilt in diesem Aufruf, bis einer der oben angegeben
  1165.        Events eingetreten ist... *)
  1166.     IF message IN occuredEvents THEN
  1167.       WITH msg DO
  1168.         CASE msgType OF
  1169.           menuSelected:         t.TT := Befehl; t.bef := MenuTabelle [selItem]|
  1170.           windRedraw:           IF NOT firstCommand THEN
  1171.                                   t.TT := Befehl; t.bef := home; (* Redraw *)
  1172.                                 END
  1173.           ELSE
  1174.         END (* CASE *);
  1175.         NormalTitle (Menu, selTitle, TRUE);
  1176.       END (* WITH *);
  1177.       EXCL (occuredEvents, message);
  1178.     ELSIF keyboard IN occuredEvents THEN
  1179.  
  1180.     (* Das folgende ist eine Umschreibung der ursprünglichen Tastatur-
  1181.        abfrage des G2E. Da MultiEvents keinen Tastenstatus liefert, können
  1182.        die Tastaturebenen nicht direkt angesprochen werden.
  1183.        
  1184.        Zunächst stellen wir fest, zu welcher Tastenart der Scancode der
  1185.        Taste gehört: *)
  1186.       t := Tastatur [0]^ [ScanTab [ORD (key.scan)]];
  1187.       CASE t.TT OF
  1188.       
  1189.              (* Wenn es ein normales Zeichen ist, übernehmen wir einfach das
  1190.                 von MultiEvents gelieferte Zeichen: *)
  1191.         Zeichen: IF key.ascii >= ' ' THEN
  1192.                    t.zch := key.ascii;
  1193.                    (* Wir übernehmen die ASCII-Zeichen aus der TOS-Tabelle *)
  1194.                  ELSIF key.ascii # nul THEN
  1195.                    (* War es ein Code kleiner als ' ', so nehmen wir an,
  1196.                       es ist die Control-Ebene gemeint: *)
  1197.                    t := Tastatur [ORD (CAST (BYTE, einStatus {Control}))]^
  1198.                         [ScanTab [ORD (key.scan)]];
  1199.                  ELSE
  1200.                    (* Es ist eine Alternate-Kombination: *)
  1201.                    t := Tastatur [ORD (CAST (BYTE, einStatus {Alternate}))]^
  1202.                         [ScanTab [ORD (key.scan)]];
  1203.                  END;
  1204.         |
  1205.         Befehl:
  1206.           (* In diesem Fall handelt es sich um eine Funktionstaste. Wir müssen
  1207.              nun den Tastaturstatus künstlich bilden: *)
  1208.            s := StatusVonKeySet (keyState);
  1209.            t := Tastatur [ORD (CAST (BYTE, s))]^ [ScanTab [ORD (key.scan)]];
  1210.         |
  1211.         ELSE;
  1212.       END (* CASE *);
  1213.       EXCL (occuredEvents, keyboard);
  1214.     ELSE
  1215.       GetMouseState (ScreenHandle, mouseLoc, buttons);
  1216.       EXCL (occuredEvents, mouseButton);
  1217.       IF msBut1 IN buttons THEN
  1218.         t.TT := Befehl;
  1219.         IF (rightShiftKey IN keyState) OR (leftShiftKey IN keyState) THEN
  1220.           t.bef := RightMous;
  1221.         ELSE
  1222.           t.bef := LeftMous;
  1223.         END;
  1224.       END (* IF Mausknopf *);
  1225.       IF msBut2 IN buttons THEN
  1226.         t.TT := Befehl;
  1227.         t.bef := RightMous;
  1228.       END (* IF Mausknopf *);
  1229.     END (* IF keyboard *);
  1230.     EXCL (occuredEvents, timer);
  1231.   UNTIL t.TT # keineTaste;
  1232.   UpdateWindow (TRUE); (* muß spätest. hier stehen wg. LiesTaste-Aufruf unten!*)
  1233.   firstCommand:= FALSE;
  1234.  
  1235.   CASE t.TT OF
  1236.     Befehl:       IF t.bef = AsciiOrd THEN
  1237.                     n := 0;
  1238.                     REPEAT
  1239.                       LiesTaste (t);
  1240.                       IF (t.TT = Zeichen) & (t.zch IN CharSet {'0'..'9'}) THEN
  1241.                         n := n * 10 + ORD (t.zch) - ORD ('0');
  1242.                       END (* IF *);
  1243.                     UNTIL ~((t.TT = Zeichen) & (t.zch IN CharSet {'0'..'9'}));
  1244.                     n := n MOD 256;
  1245.                     t.TT := Zeichen; t.zch := CHR (n);
  1246.                   ELSIF t.bef = GMECopyrightBox THEN
  1247.                     ShowGMEInfo;
  1248.                   END (* IF *);
  1249.     |
  1250.     Tastenebene:  WHILE t.TT = Tastenebene DO
  1251.                     MultiEvent (EventSet {keyboard, mouseButton, message},
  1252.                                 noClicks, butMask, MButtonSet{},
  1253.                                 moveDirec1, rect1Size,
  1254.                                 moveDirec2, rect2Size,
  1255.                                 msg, time, mouseLoc, buttons,
  1256.                                 keyState, key, doneClicks, localEvents);
  1257.  
  1258.                     IF keyboard IN localEvents THEN
  1259.                       tt := Tastatur [0]^ [ScanTab [ORD (key.scan)]];
  1260.                       IF (tt.TT = Zeichen) & (key.ascii <= 'z') THEN
  1261.                         t := t.teb^ [ScanTab [ORD (key.scan)]];
  1262.                       ELSE t.TT := keineTaste;
  1263.                       END (* IF *);
  1264.                     (*ELSE t.TT := keineTaste;*)
  1265.                     END (* IF keyboard *);
  1266.  
  1267.                    END (* WHILE *);
  1268.     |
  1269.     ELSE;
  1270.   END (* CASE *);
  1271. END LiesTaste;
  1272.  
  1273. PROCEDURE LiesTastMaus (VAR t: einTasteneintrag; keys: einStatus);
  1274. END LiesTastMaus;
  1275.  
  1276. PROCEDURE LiesZeichen (VAR ch: CHAR);
  1277. VAR     t:      einTasteneintrag;
  1278. BEGIN
  1279.   LiesTaste (t);
  1280.   IF t.TT = Zeichen THEN ch := t.zch ELSE ch := nul; END;
  1281. END LiesZeichen;
  1282.  
  1283. PROCEDURE LiesBefehl (VAR b: einBefehl);
  1284. VAR     t:      einTasteneintrag;
  1285. BEGIN
  1286.   LiesTaste (t);
  1287.   IF t.TT = Befehl THEN b := t.bef; ELSE b := nothing; END;
  1288. END LiesBefehl;
  1289.  
  1290.  
  1291. VAR     RessPfad:       eineInfo;
  1292.         gefunden:       BOOLEAN;
  1293.         DateiName:      ARRAY [0..13] OF CHAR;
  1294.         termHdl:        TermCarrier;
  1295.  
  1296. BEGIN
  1297. (* GEM-Menüleiste: *)
  1298.   
  1299.   DisableBreak;
  1300.   IF NOT KbdEventsInstalled () THEN
  1301.     CatchProcessTerm (termHdl, DeInstallKbdEvents, MemArea {NIL, 0});
  1302.     InstallKbdEvents
  1303.   END;
  1304.   
  1305.   HomePath:= ShellPath;
  1306.   DateiName := 'GMEMENUE.RSC';
  1307.   SearchFile (DateiName, StdPaths, fromStart, gefunden, RessPfad);
  1308.   
  1309.   LoadResource (RessPfad); (* Muß auf meinem Pfad sein! *)
  1310.   IF GemError() THEN
  1311.     Nachricht (' Die Datei GMEMENUE.RSC| wurde nicht gefunden!');
  1312.     CursorAus; MausEin; (* Schaltet wieder auf GEM-Oberflaeche zurueck *)
  1313.     (*TastReset; *)
  1314.     ClearAES;
  1315.     TermProcess (0);
  1316.   END;
  1317.   Menu := ResourceAddr (treeRsrc, Gmemenue);
  1318.   MenuBar (Menu, TRUE);
  1319.   noClicks := 1;
  1320.   butMask := MButtonSet {};
  1321.   butState := MButtonSet {};
  1322.   moveDirec1 := lookForEntry; moveDirec2 := lookForEntry;
  1323.   WITH rect1Size DO x := 0; y := 0; w := 0; h := 0; END (* WITH *);
  1324.   WITH rect2Size DO x := 0; y := 0; w := 0; h := 0; END (* WITH *);
  1325.   time := 0; (* MUSS NULL SEIN, sonst geht Autorepeat nicht!? *)
  1326.  
  1327.   InitTastatur (Tastatur);
  1328.   InitMenuTabelle;
  1329.   ConfigInit := FALSE;
  1330.   
  1331.   oldRight:= FALSE;
  1332.   OldClipLeer:= FALSE;
  1333.   OldDoClipboard:= ~DoClipboard;
  1334.   OldNextPuff:= FALSE;
  1335.   OldModus := Moden {};
  1336.   firstCommand:= TRUE;
  1337. END GMEConfig.
  1338.